home *** CD-ROM | disk | FTP | other *** search
/ Speccy ClassiX 1998 / Speccy ClassiX 98.iso / amiga_system / the_aminet / dev / gcc / ixemulsrc.lha / ixemul-41.4 / library / mathsup.c < prev    next >
C/C++ Source or Header  |  1995-05-20  |  10KB  |  510 lines
  1. /*
  2.  *  This file is part of ixemul.library for the Amiga.
  3.  *  Copyright (C) 1991, 1992  Markus M. Wild
  4.  *  Portions Copyright (C) 1994 Rafael W. Luebbert
  5.  *
  6.  *  This library is free software; you can redistribute it and/or
  7.  *  modify it under the terms of the GNU Library General Public
  8.  *  License as published by the Free Software Foundation; either
  9.  *  version 2 of the License, or (at your option) any later version.
  10.  *
  11.  *  This library is distributed in the hope that it will be useful,
  12.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14.  *  Library General Public License for more details.
  15.  *
  16.  *  You should have received a copy of the GNU Library General Public
  17.  *  License along with this library; if not, write to the Free
  18.  *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  *
  20.  *  $Id: mathsup.c,v 1.6 1994/06/25 12:15:02 rluebbert Exp $
  21.  *
  22.  *  $Log: mathsup.c,v $
  23.  *  Revision 1.6  1994/06/25  12:15:02  rluebbert
  24.  *  removed errno from pow. Probably not a good idea,
  25.  *  but I'm tired of patching stuff right now.
  26.  *
  27.  *  Revision 1.5  1994/06/25  12:05:50  rluebbert
  28.  *  bugfix
  29.  *
  30.  *  Revision 1.4  1994/06/25  11:53:41  rluebbert
  31.  *  Put in 68881 pow and moved Commodore's to ifndef __HAVE_68881
  32.  *
  33.  *  Revision 1.3  1994/06/19  15:14:01  rluebbert
  34.  *  *** empty log message ***
  35.  *
  36.  *
  37.  */
  38.  
  39. extern struct MathIeeeDoubTransBase * MathIeeeDoubTransBase;
  40. extern struct MathIeeeDoubBasBase * MathIeeeDoubBasBase;
  41.  
  42.  
  43. double sincos (double* pf2, double parm)
  44. {
  45.     register double res __asm("d0");
  46.     register void *a6 __asm ("a6");
  47.     register double* a0 __asm("a0");
  48.     register double d0 __asm("d0");
  49.  
  50.     a6 = MathIeeeDoubTransBase;
  51.     a0 = pf2;
  52.     d0 = parm;
  53.     __asm volatile ("
  54.     jsr a6@(-0x36)"
  55.     : "=r" (res)
  56.     : "r" (a6), "r" (a0), "r" (d0)
  57.     : "d0", "d1", "a0", "a1");
  58.     return res;
  59. }
  60.  
  61. #ifndef __HAVE_68881
  62.  
  63. /* GRRRR Commodore does it the other way round... */
  64. double const pow (double arg, double exp)
  65. {
  66.     register double res __asm("d0");
  67.     register void *a6 __asm ("a6");
  68.     register double d2 __asm("d2");
  69.     register double d3 __asm("d0");
  70.  
  71.     a6 = MathIeeeDoubTransBase;
  72.     d2 = exp;    /* invert arguments here, so exp really is arg and vice versa */
  73.     d3 = arg;
  74.     __asm volatile ("
  75.     jsr a6@(-0x5a)"
  76.     : "=r" (res)
  77.     : "r" (a6), "r" (d2), "r" (d3)
  78.     : "d0", "d1", "a0", "a1", "d2", "d3");
  79.     return res;
  80. }
  81. double const atan (double parm)
  82. {
  83.     register double res __asm("d0");
  84.     register void *a6 __asm ("a6");
  85.     register double d0 __asm("d0");
  86.  
  87.     a6 = MathIeeeDoubTransBase;
  88.     d0 = parm;
  89.     __asm volatile ("
  90.     jsr a6@(-0x1e)"
  91.     : "=r" (res)
  92.     : "r" (a6), "r" (d0)
  93.     : "d0", "d1", "a0", "a1");
  94.     return res;
  95. }
  96. double const sin (double parm)
  97. {
  98.     register double res __asm("d0");
  99.     register void *a6 __asm ("a6");
  100.     register double d0 __asm("d0");
  101.  
  102.     a6 = MathIeeeDoubTransBase;
  103.     d0 = parm;
  104.     __asm volatile ("
  105.     jsr a6@(-0x24)"
  106.     : "=r" (res)
  107.     : "r" (a6), "r" (d0)
  108.     : "d0", "d1", "a0", "a1");
  109.     return res;
  110. }
  111. double const cos (double parm)
  112. {
  113.     register double res __asm("d0");
  114.     register void *a6 __asm ("a6");
  115.     register double d0 __asm("d0");
  116.  
  117.     a6 = MathIeeeDoubTransBase;
  118.     d0 = parm;
  119.     __asm volatile ("
  120.     jsr a6@(-0x2a)"
  121.     : "=r" (res)
  122.     : "r" (a6), "r" (d0)
  123.     : "d0", "d1", "a0", "a1");
  124.     return res;
  125. }
  126. double const tan (double parm)
  127. {
  128.     register double res __asm("d0");
  129.     register void *a6 __asm ("a6");
  130.     register double d0 __asm("d0");
  131.  
  132.     a6 = MathIeeeDoubTransBase;
  133.     d0 = parm;
  134.     __asm volatile ("
  135.     jsr a6@(-0x30)"
  136.     : "=r" (res)
  137.     : "r" (a6), "r" (d0)
  138.     : "d0", "d1", "a0", "a1");
  139.     return res;
  140. }
  141. double const sinh (double parm)
  142. {
  143.     register double res __asm("d0");
  144.     register void *a6 __asm ("a6");
  145.     register double d0 __asm("d0");
  146.  
  147.     a6 = MathIeeeDoubTransBase;
  148.     d0 = parm;
  149.     __asm volatile ("
  150.     jsr a6@(-0x3c)"
  151.     : "=r" (res)
  152.     : "r" (a6), "r" (d0)
  153.     : "d0", "d1", "a0", "a1");
  154.     return res;
  155. }
  156. double const cosh (double parm)
  157. {
  158.     register double res __asm("d0");
  159.     register void *a6 __asm ("a6");
  160.     register double d0 __asm("d0");
  161.  
  162.     a6 = MathIeeeDoubTransBase;
  163.     d0 = parm;
  164.     __asm volatile ("
  165.     jsr a6@(-0x42)"
  166.     : "=r" (res)
  167.     : "r" (a6), "r" (d0)
  168.     : "d0", "d1", "a0", "a1");
  169.     return res;
  170. }
  171. double const tanh (double parm)
  172. {
  173.     register double res __asm("d0");
  174.     register void *a6 __asm ("a6");
  175.     register double d0 __asm("d0");
  176.  
  177.     a6 = MathIeeeDoubTransBase;
  178.     d0 = parm;
  179.     __asm volatile ("
  180.     jsr a6@(-0x48)"
  181.     : "=r" (res)
  182.     : "r" (a6), "r" (d0)
  183.     : "d0", "d1", "a0", "a1");
  184.     return res;
  185. }
  186. double const exp (double parm)
  187. {
  188.     register double res __asm("d0");
  189.     register void *a6 __asm ("a6");
  190.     register double d0 __asm("d0");
  191.  
  192.     a6 = MathIeeeDoubTransBase;
  193.     d0 = parm;
  194.     __asm volatile ("
  195.     jsr a6@(-0x4e)"
  196.     : "=r" (res)
  197.     : "r" (a6), "r" (d0)
  198.     : "d0", "d1", "a0", "a1");
  199.     return res;
  200. }
  201. double const log (double parm)
  202. {
  203.     register double res __asm("d0");
  204.     register void *a6 __asm ("a6");
  205.     register double d0 __asm("d0");
  206.  
  207.     a6 = MathIeeeDoubTransBase;
  208.     d0 = parm;
  209.     __asm volatile ("
  210.     jsr a6@(-0x54)"
  211.     : "=r" (res)
  212.     : "r" (a6), "r" (d0)
  213.     : "d0", "d1", "a0", "a1");
  214.     return res;
  215. }
  216. double const sqrt (double parm)
  217. {
  218.     register double res __asm("d0");
  219.     register void *a6 __asm ("a6");
  220.     register double d0 __asm("d0");
  221.  
  222.     a6 = MathIeeeDoubTransBase;
  223.     d0 = parm;
  224.     __asm volatile ("
  225.     jsr a6@(-0x60)"
  226.     : "=r" (res)
  227.     : "r" (a6), "r" (d0)
  228.     : "d0", "d1", "a0", "a1");
  229.     return res;
  230. }
  231. double const asin (double parm)
  232. {
  233.     register double res __asm("d0");
  234.     register void *a6 __asm ("a6");
  235.     register double d0 __asm("d0");
  236.  
  237.     a6 = MathIeeeDoubTransBase;
  238.     d0 = parm;
  239.     __asm volatile ("
  240.     jsr a6@(-0x72)"
  241.     : "=r" (res)
  242.     : "r" (a6), "r" (d0)
  243.     : "d0", "d1", "a0", "a1");
  244.     return res;
  245. }
  246. double const acos (double parm)
  247. {
  248.     register double res __asm("d0");
  249.     register void *a6 __asm ("a6");
  250.     register double d0 __asm("d0");
  251.  
  252.     a6 = MathIeeeDoubTransBase;
  253.     d0 = parm;
  254.     __asm volatile ("
  255.     jsr a6@(-0x78)"
  256.     : "=r" (res)
  257.     : "r" (a6), "r" (d0)
  258.     : "d0", "d1", "a0", "a1");
  259.     return res;
  260. }
  261. double const log10 (double parm)
  262. {
  263.     register double res __asm("d0");
  264.     register void *a6 __asm ("a6");
  265.     register double d0 __asm("d0");
  266.  
  267.     a6 = MathIeeeDoubTransBase;
  268.     d0 = parm;
  269.     __asm volatile ("
  270.     jsr a6@(-0x7e)"
  271.     : "=r" (res)
  272.     : "r" (a6), "r" (d0)
  273.     : "d0", "d1", "a0", "a1");
  274.     return res;
  275. }
  276. double const floor (double parm)
  277. {
  278.     register double res __asm("d0");
  279.     register void *a6 __asm ("a6");
  280.     register double d0 __asm("d0");
  281.  
  282.     a6 = MathIeeeDoubBasBase;
  283.     d0 = parm;
  284.     __asm volatile ("
  285.     jsr a6@(-0x5a)"
  286.     : "=r" (res)
  287.     : "r" (a6), "r" (d0)
  288.     : "d0", "d1", "a0", "a1");
  289.     return res;
  290. }
  291. double const ceil (double parm)
  292. {
  293.     register double res __asm("d0");
  294.     register void *a6 __asm ("a6");
  295.     register double d0 __asm("d0");
  296.  
  297.     a6 = MathIeeeDoubBasBase;
  298.     d0 = parm;
  299.     __asm volatile ("
  300.     jsr a6@(-0x60)"
  301.     : "=r" (res)
  302.     : "r" (a6), "r" (d0)
  303.     : "d0", "d1", "a0", "a1");
  304.     return res;
  305. }
  306.  
  307. #else /* There is a 68881 or 68882 (__HAVE_68881 is defined) */
  308.  
  309.  
  310. const double sin(double x)
  311. {
  312.   double value;
  313.  
  314.   __asm ("fsin%.x %1,%0"
  315.      : "=f" (value)
  316.      : "f" (x));
  317.   return value;
  318. }
  319.  
  320. const double cos(double x)
  321. {
  322.   double value;
  323.  
  324.   __asm ("fcos%.x %1,%0"
  325.      : "=f" (value)
  326.      : "f" (x));
  327.   return value;
  328. }
  329.  
  330. const double tan(double x)
  331. {
  332.   double value;
  333.  
  334.   __asm ("ftan%.x %1,%0"
  335.      : "=f" (value)
  336.      : "f" (x));
  337.   return value;
  338. }
  339. const double asin(double x)
  340. {
  341.   double value;
  342.  
  343.   __asm ("fasin%.x %1,%0"
  344.      : "=f" (value)
  345.      : "f" (x));
  346.   return value;
  347. }
  348.  
  349. const double acos(double x)
  350. {
  351.   double value;
  352.  
  353.   __asm ("facos%.x %1,%0"
  354.      : "=f" (value)
  355.      : "f" (x));
  356.   return value;
  357. }
  358.  
  359. const double atan(double x)
  360. {
  361.   double value;
  362.  
  363.   __asm ("fatan%.x %1,%0"
  364.      : "=f" (value)
  365.      : "f" (x));
  366.   return value;
  367. }
  368. const double sinh(double x)
  369. {
  370.   double value;
  371.  
  372.   __asm ("fsinh%.x %1,%0"
  373.      : "=f" (value)
  374.      : "f" (x));
  375.   return value;
  376. }
  377.  
  378. const double cosh(double x)
  379. {
  380.   double value;
  381.  
  382.   __asm ("fcosh%.x %1,%0"
  383.      : "=f" (value)
  384.      : "f" (x));
  385.   return value;
  386. }
  387.  
  388. const double tanh(double x)
  389. {
  390.   double value;
  391.  
  392.   __asm ("ftanh%.x %1,%0"
  393.      : "=f" (value)
  394.      : "f" (x));
  395.   return value;
  396. }
  397. const double exp(double x)
  398. {
  399.   double value;
  400.  
  401.   __asm ("fetox%.x %1,%0"
  402.      : "=f" (value)
  403.      : "f" (x));
  404.   return value;
  405. }
  406. const double log(double x)
  407. {
  408.   double value;
  409.  
  410.   __asm ("flogn%.x %1,%0"
  411.      : "=f" (value)
  412.      : "f" (x));
  413.   return value;
  414. }
  415. const double log10(double x)
  416. {
  417.   double value;
  418.  
  419.   __asm ("flog10%.x %1,%0"
  420.      : "=f" (value)
  421.      : "f" (x));
  422.   return value;
  423. }
  424.  
  425. const double sqrt(double x)
  426. {
  427.   double value;
  428.  
  429.   __asm ("fsqrt%.x %1,%0"
  430.      : "=f" (value)
  431.      : "f" (x));
  432.   return value;
  433. }
  434. const double ceil(double x)
  435. {
  436.   int rounding_mode, round_up;
  437.   double value;
  438.  
  439.   __asm __volatile ("fmove%.l fpcr,%0"
  440.           : "=dm" (rounding_mode)
  441.           : /* no inputs */ );
  442.   round_up = rounding_mode | 0x30;
  443.   __asm __volatile ("fmove%.l %0,fpcr"
  444.           : /* no outputs */
  445.           : "dmi" (round_up));
  446.   __asm __volatile ("fint%.x %1,%0"
  447.           : "=f" (value)
  448.           : "f" (x));
  449.   __asm __volatile ("fmove%.l %0,fpcr"
  450.           : /* no outputs */
  451.           : "dmi" (rounding_mode));
  452.   return value;
  453. }
  454.  
  455. const double floor(double x)
  456. {
  457.   int rounding_mode, round_down;
  458.   double value;
  459.  
  460.   __asm __volatile ("fmove%.l fpcr,%0"
  461.           : "=dm" (rounding_mode)
  462.           : /* no inputs */ );
  463.   round_down = (rounding_mode & ~0x10)
  464.         | 0x20;
  465.   __asm __volatile ("fmove%.l %0,fpcr"
  466.           : /* no outputs */
  467.           : "dmi" (round_down));
  468.   __asm __volatile ("fint%.x %1,%0"
  469.           : "=f" (value)
  470.           : "f" (x));
  471.   __asm __volatile ("fmove%.l %0,fpcr"
  472.           : /* no outputs */
  473.           : "dmi" (rounding_mode));
  474.   return value;
  475. }
  476.  
  477. #define NAN(value)   __asm ("fmoved %#0rnan,%0" : "=f" (value): )
  478. const double pow(double x, double y)
  479. {
  480. register double value;
  481.  
  482.   if (x > 0)   return exp (y * log (x));
  483.   
  484.   if (x == 0)
  485.     {
  486.     if (y==0)
  487.     {
  488.      NAN(value);
  489.      return value;
  490.     }
  491.  
  492.        return (0.0) ;
  493.     }
  494.  
  495.       __asm ("fintrz%.x %1,%0"
  496.          : "=f" (value)            /* integer-valued float */
  497.          : "f" (y));
  498.  
  499.     if (y!=value)
  500.     {
  501.       NAN(value);
  502.       return value;
  503.     }
  504.     x=y*log(-x);
  505.     return ( ( ((int)y&1) == 0) ? exp(x) : -exp(x) );
  506.  
  507. }
  508.  
  509. #endif /* __HAVE_68881 */
  510.